Triangulating a Simple Polygon in Linear Time

Triangulating a simple polygon has been one of the most outstanding open problems in two-dimensional computational geometry. It is a basic primitive in computer graphics and, generally, seems the natural preprocessing step for most nontrivial operations on simple polygons [5,13]. Recall that to triangulate a polygon is t o partition it into triangles without adding any new vertices. Despite its apparent simplicity, however, the triangulation problem has remained elusive. In 1978, Garey et al. (111 gave an O(n1ogn)-time algorithm for triangulating a simple ngon. While it was widely believed that triangulating should be easier than sorting, no proof was to be found until 1988, when Tarjan and Van Wyk [25] discovered an O(nlog1og n)-time algorithm. Following this breakthrough, Clarkson, Tarjan, and Van Wyk [7] discovered a Las Vegas algorithm with O(nlog* n) expected time. Recently, Kirkpatrick, Klawe, and Tarjan [19] gave a new, conceptually simpler O ( n log log n)-time algorithm, and they also derived an O(n1og' n ) bound for the case where vertices have polynomially-bounded integer coordinates. Other results on the triangulation problem include linear or quasi-linear algorithms for restricted classes of polygons [6,10,16,27]. Our main result is a linear-time deterministic algorithm for triangulating a simple polygon. The algorithm is elementary in that it does not require the use of any complicated data structure; in particular, it does not need dynamic search trees, finger trees, or any fancy point location structures. As was observed in (6,101 a triangulation of a polygon can be obtained directly from its horizontal visibility map: this is the partition of the polygon obtained by drawing horizontal chords from the vertices. We can extend this notion easily and speak, more generally, of the visibility map of any simple polygonal curve (Figure 2.1). Chazelle and Incerpi [6] showed how to build the visibility map of an n-vertex curve in O(n1ogn) time, using divide-and-conquer. Their algorithm mimics mergesort: Assuming that n is a power of 2, at the Rth stage ( I C = 1,2,. . . ,log n), the boundary of the polygon is decomposed into chains of size 2k, whose visibility maps are computed by piecing together the maps obtained at the previous stage. Each stage can be accomplished in a linear number of operations, so computing the visibility map of the polygon takes O(n1og n) time. The new algorithm follows exactly the same pattern: It goes through an up-phase of log n stages, each involving the merging of maps obtained at the previous stage. The novelty we bring into this process is to use only coarse samples of the visibility maps during the merges. In this way, we can carry out an entire stage in sublinear time and beat n log TI. These samples are uniform submaps of the visibility maps; uniform i n the sense that they approximate the visibility maps anywhere equally well. Of course, in the end, we also need an efficient way to refine the submap for the whole polygon into its full-fledged visibility map. After this is done, it takes only linear time to derive a triangulation. To refine a submap we go down through stages in reverse (a down-phase): each transition refines the submap incrementally, until we get back to the first stage, at which point the full visibility map emerges at last. Figure 1.1 illustrates the meaning of 11,. lipand down-phases.